C# 多线程

线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。

线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。

到目前为止我们编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但是，这样子应用程序同时只能执行一个任务。为了同时执行多个任务，它可以被划分为更小的线程。

一、线程生命周期

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

下面列出了线程生命周期中的各种状态：

1. 未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。

2. 就绪状态：当线程准备好运行并等待 CPU 周期时的状况。

3. 不可运行状态：下面的几种情况下线程是不可运行的：

    • 已经调用 Sleep 方法
    • 已经调用 Wait 方法
    • 通过 I/O 操作阻塞
   

4. 死亡状态：当线程已完成执行或已中止时的状况。

二、主线程

在 C# 中，System.Threading.Thread 类用于线程的工作。它允许创建并访问多线程应用程序中的单个线程。进程中第一个被执行的线程称为主线程。

当 C# 程序开始执行时，主线程自动创建。使用 Thread 类创建的线程被主线程的子线程调用。您可以使用 Thread 类的 CurrentThread 属性访问线程。

下面的程序演示了主线程的执行：

    using System;
    using System.Threading;

    namespace MultithreadingApplication
    {
        class MainThreadProgram
        {
            static void Main(string[] args)
            {
                Thread th = Thread.CurrentThread;
                th.Name = "MainThread";
                Console.WriteLine("This is {0}", th.Name);
                Console.ReadKey();
            }
        }
    }

当上面的代码被编译和执行时，它会产生下列结果：

    This is MainThread

三、Thread 类常用的属性和方法

下表列出了 Thread 类的一些常用的 属性：

下表列出了 Thread 类的一些常用的 方法：

四、创建线程

线程是通过扩展 Thread 类创建的。扩展的 Thread 类调用 Start() 方法来开始子线程的执行。

下面的程序演示了这个概念：

    using System;
    using System.Threading;

    namespace MultithreadingApplication
    {
        class ThreadCreationProgram
        {
            public static void CallToChildThread()
            {
                Console.WriteLine("Child thread starts");
            }

            static void Main(string[] args)
            {
                ThreadStart childref = new ThreadStart(CallToChildThread);
                Console.WriteLine("In Main: Creating the Child thread");
                Thread childThread = new Thread(childref);
                childThread.Start();
                Console.ReadKey();
            }
        }
    }

当上面的代码被编译和执行时，它会产生下列结果：

    In Main: Creating the Child thread
    Child thread starts

五、管理线程

Thread 类提供了各种管理线程的方法。

下面的实例演示了 sleep() 方法的使用，用于在一个特定的时间暂停线程。

    using System;
    using System.Threading;

    namespace MultithreadingApplication
    {
        class ThreadCreationProgram
        {
            public static void CallToChildThread()
            {
                Console.WriteLine("Child thread starts");
                // 线程暂停 5000 毫秒
                int sleepfor = 5000; 
                Console.WriteLine("Child Thread Paused for {0} seconds", 
                                  sleepfor / 1000);
                Thread.Sleep(sleepfor);
                Console.WriteLine("Child thread resumes");
            }

            static void Main(string[] args)
            {
                ThreadStart childref = new ThreadStart(CallToChildThread);
                Console.WriteLine("In Main: Creating the Child thread");
                Thread childThread = new Thread(childref);
                childThread.Start();
                Console.ReadKey();
            }
        }
    }

当上面的代码被编译和执行时，它会产生下列结果：

    In Main: Creating the Child thread
    Child thread starts
    Child Thread Paused for 5 seconds
    Child thread resumes

六、销毁线程

Abort() 方法用于销毁线程。

通过抛出 threadabortexception 在运行时中止线程。这个异常不能被捕获，如果有 finally 块，控制会被送至 finally 块。

下面的程序说明了这点：

    using System;
    using System.Threading;

    namespace MultithreadingApplication
    {
        class ThreadCreationProgram
        {
            public static void CallToChildThread()
            {
                try
                {

                    Console.WriteLine("Child thread starts");
                    // 计数到 10
                    for (int counter = 0; counter <= 10; counter++)
                    {
                        Thread.Sleep(500);
                        Console.WriteLine(counter);
                    }
                    Console.WriteLine("Child Thread Completed");

                }
                catch (ThreadAbortException e)
                {
                    Console.WriteLine("Thread Abort Exception");
                }
                finally
                {
                    Console.WriteLine("Couldn't catch the Thread Exception");
                }

            }

            static void Main(string[] args)
            {
                ThreadStart childref = new ThreadStart(CallToChildThread);
                Console.WriteLine("In Main: Creating the Child thread");
                Thread childThread = new Thread(childref);
                childThread.Start();
                // 停止主线程一段时间
                Thread.Sleep(2000);
                // 现在中止子线程
                Console.WriteLine("In Main: Aborting the Child thread");
                childThread.Abort();
                Console.ReadKey();
            }
        }
    }

当上面的代码被编译和执行时，它会产生下列结果：

    In Main: Creating the Child thread
    Child thread starts
    0
    1
    2
    In Main: Aborting the Child thread
    Thread Abort Exception
    Couldn't catch the Thread Exception

🔚